Pipelined read-modify-write operations in cache memory

ABSTRACT

In described examples, a processor system includes a processor core that generates memory write requests, a cache memory, and a memory pipeline of the cache memory. The memory pipeline has a holding buffer, an anchor stage, and an RMW pipeline. The anchor stage determines whether a data payload of a write request corresponds to a partial write. If so, the data payload is written to the holding buffer and conforming data is read from a corresponding cache memory address to merge with the data payload. The RMW pipeline has a merge stage and a syndrome generation stage. The merge stage merges the data payload in the holding buffer with the conforming data to make merged data. The syndrome generation stage generates an ECC syndrome using the merged data. The memory pipeline writes the data payload and ECC syndrome to the cache memory.

CROSS-REFERENCE TO RELATED APPLICATION

This application claims the benefit of and priority to U.S. Provisional Patent Application Ser. No. 62/852,420, filed May 24, 2019, entitled “READ-MODIFY-WRITE OPERATIONS IN AN L2 CACHE,” which is hereby fully incorporated herein by reference.

TECHNICAL FIELD

The present disclosure relates generally to a processing device that can be formed as part of an integrated circuit, such as a system on a chip (SoC). More specifically, this disclosure relates to improvements in management of read-modify-write operations in a memory system of such a processing device.

BACKGROUND

An SOC is an integrated circuit with multiple functional blocks on a single die, such as one or more processor cores, memory, and input and output.

Memory write requests are generated by ongoing system processes by a processor connected to the bus fabric, such as a central processing unit (CPU) or a digital signal processor (DSP), and are directed towards a particular system memory, such as a cache memory or a main memory. Memory can be, for example, a static random-access memory (SRAM). Memory write requests include a data payload to be written, and may include a code used to correct errors in the data payload (the data payload can be considered to include the ECC syndrome). This code is referred to herein as an error correction code (ECC) syndrome. The amount of data corresponding to an ECC syndrome, which can be corrected using the ECC syndrome, is referred to herein as a chunk. A chunk can be, for example, a single word, such as a 32 byte word, or another data length.

Hierarchical memory moves data and instructions between memory blocks with different read/write response times for respective processor cores (such as a CPU or a DSP). For example, memories which are more local to respective processor cores will typically have lower response times. Hierarchical memories include cache memory systems with multiple levels (such as L1, L2, and L3), in which different levels describe different degrees of locality or different average response times of the cache memories to respective processor cores. Herein, the more local or lower response time cache memory (such as an L1 cache) is referred to as being a higher level cache memory than a less local or higher response time lower level cache memory (such as an L2 cache or L3 cache).

SUMMARY

In described examples, a processor system includes a processor core that generates memory write requests, a cache memory, and a memory pipeline of the cache memory. The memory pipeline has a holding buffer, an anchor stage, and a Read-Modify-Write (RMW) pipeline. The anchor stage determines whether a data payload of a write request corresponds to a partial write. If so, the data payload is written to the holding buffer and conforming data is read from a corresponding cache memory address to merge with the data payload. The RMW pipeline has a merge stage and a syndrome generation stage. The merge stage merges the data payload in the holding buffer with the conforming data to make merged data. The syndrome generation stage generates an ECC syndrome using the merged data. The memory pipeline writes the data payload and ECC syndrome to the cache memory.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a block diagram of an example processor that is a portion of a system on a chip (SoC).

FIG. 2 is a block diagram of an example memory pipeline included within or associated with a memory controller of FIG. 1.

FIG. 3 is a block diagram of an example RMW memory pipeline, as part of a processor, for processing RMW memory transactions.

FIG. 4A shows a table providing an example list of different combinations of chunk contents in a data payload of a write request that targets a write at an address in a cache memory.

FIG. 4B shows a table providing an example list of operations to use (RMW, full write, etc.) for corresponding cases of FIG. 4A.

FIG. 4C shows a table providing an alternative example list of whether an RMW is utilized for corresponding cases of FIG. 4A.

DETAILED DESCRIPTION

FIG. 1 is a block diagram of an example processor 100 that is a portion of an SoC 10. SoC 10 includes a processor core 102, such as a CPU or DSP, that generates new data. Processor 100 can include a clock 103, which can be part of processor core 102 or separate therefrom (separate clock not shown). Processor core 102 also generates memory read requests that request reads from, as well as memory write requests that request writes to, a data memory controller 104 (DMC) and a streaming engine 106. In some embodiments, processor core 102 generates one read request or write request per cycle of clock 103 of processor core 102. Processor core 102 is also coupled to receive instructions from a program memory controller 108 (PMC), which retrieves those instructions from program memory, such as an L1P cache 112. Streaming engine 106 facilitates processor core 102 by sending certain memory transactions and other memory-related messages that bypass DMC 104 and PMC 108.

SoC 10 has a hierarchical memory system. Each cache at each level may be unified or divided into separate data and program caches. For example, the DMC 104 may be coupled to a level 1 data cache 110 (L1D cache) to control data writes to and data reads from the L1D cache 110. Similarly, the PMC 108 may be coupled to a level 1 program cache 112 (L1P cache) to read instructions for execution by processor core 102 from the L1P cache 112. (In this example, processor core 102 does not generate writes to L1P cache 112.) A unified memory controller 114 (UMC) for a level 2 cache (L2 cache 116, such as L2 SRAM) is communicatively coupled to receive read and write memory access requests from DMC 104 and PMC 108, and to receive read requests from streaming engine 106, PMC 108, and a memory management unit 117 (MMU). UMC 114 is communicatively coupled to pass read data (from beyond level 1 caching) to DMC 104, streaming engine 106, and PMC 108, which is then passed on to processor core 102. UMC 114 is also coupled to control writes to, and reads from, L2 cache 116, and to pass memory access requests to a level 3 cache controller 118 (L3 controller). L3 controller 118 is coupled to control writes to, and reads from, L3 cache 119. UMC 114 is coupled to receive data read from L2 cache 116 and L3 cache 119 (via L3 controller 118). UMC 114 is configured to control pipelining of memory transactions (read and write requests) for instructions and data. L3 controller 118 is coupled to control writes to, and reads from, L3 cache 119, and to mediate transactions with exterior functions 120 that are exterior to processor 100, such as other processor cores, peripheral functions of the SOC 10, and/or other SoCs. That is, L3 controller 118 is a shared memory controller of the SoC 10, and L3 cache 119 is a shared cache memory of the SoC 10. Accordingly, memory transactions relating to processor 100 and exterior functions 120 pass through L3 controller 118. Memory transactions are generated by processor core 102 and are communicated towards lower level cache memory, or are generated by exterior functions 120 and communicated towards higher level cache memory.

MMU 117 provides address translation and memory attribute information to the processor core 102. It does this by looking up information in tables that are stored in memory (connection between MMU 117 and UMC 114 enables MMU 117 to use read requests to access memory containing the tables).

FIG. 2 is a block diagram including an example memory pipeline 200 for receiving and servicing memory transaction requests and included within or associated with the FIG. 1 UMC 114, so for illustration FIG. 2 also repeats various blocks from FIG. 1 that communicate with UMC 114. Memory pipeline 200 includes an initial scheduling block 202 coupled to an integer number M of pipeline banks 206. Each pipeline bank 206 includes an integer number P of stages 208 and is illustrated as a vertical column below initial scheduling block 202. Different ones of the stages 208 can perform different functions, such as (without limitation) translation between a CPU address and a cache address, cache hit detection, checking for errors such as addressing or out-of-range errors, and writing to the corresponding cache memory.

DMC 104 is coupled to initial scheduling block 202 by a bus 204-1 that is a number N₁ lines wide, enabling DMC 104 to make a read or write request transferring a number N₁ bits of data at a time. Streaming engine 106 is coupled to initial scheduling block 202 by a bus 204-2 that is a number N₂ lines wide, enabling streaming engine 106 to make a read request transferring a number N₂ bits of data at a time. PMC 108 is coupled to initial scheduling block 202 by a bus 204-3 that is a number N₃ lines wide, enabling PMC 108 to make a read request transferring a number N₃ bits of data at a time. L3 controller 118 is coupled to initial scheduling block 202 by a bus 204-4 that is a number N₄ lines wide, enabling L3 118 to make a read or write request transferring a number N4 bits of data at a time. MMU 117 is coupled to initial scheduling block 202 by a bus 204-5 that is a number Ns lines wide, enabling MMU 117 to make a read request transferring a number Ns bits of data at a time.

When a memory controller of processor 100 (such as DMC 104, streaming engine 106, PMC 108, or L3 controller 118) communicates to UMC 114 a request for a read from, or a write to, a memory intermediated by UMC 114 (such as L2 cache 116, L3 cache 119, or a memory in exterior functions 120), initial scheduling block 202 schedules the request to be handled by an appropriate pipeline bank 206 for the particular request. Accordingly, initial scheduling block 202 performs arbitration on read and write requests. Arbitration determines which pipeline bank 206 will receive which of the memory transactions queued at initial scheduling block 202, and in what order. Typically, a read or write request can only be scheduled into a corresponding one of pipeline banks 206, depending on, for example, the memory address of the data being written or requested, request load of pipeline banks 206, or a pseudo-random function. Initial scheduling block 202 schedules read and write requests received from DMC 104, streaming engine 106, PMC 108, and L3 controller 118, by selecting among the first stages of pipeline banks 206. Memory transactions requested to be performed on L3 cache 119 (or exterior functions 120) are arbitrated and scheduled into an L3 cache pipeline by an L3 cache scheduling block (not shown) in L3 controller 118 after passing through memory pipeline 200 corresponding to L2 cache 116 (pipeline banks 206, and potentially bus snooping-related stages, which are not shown).

Request scheduling prevents conflicts between read or write requests that are to be handled by the same pipeline bank 206, and preserves memory coherence (further discussed below). For example, request scheduling maintains order among memory transactions that are placed into a memory transaction queue (memory access request queue) of initial scheduling block 202 by different memory controllers of processor 100, or by different bus lines of a same memory controller.

Further, a pipeline memory transaction (a read or write request) sent by DMC 104 or PMC 108 is requested because the memory transaction has already passed through a corresponding level 1 cache pipeline (in DMC 104 for L1D cache 110, and in PMC 108 for L1P cache 112), and is either targeted to a lower level cache (or exterior functions 120) or has produced a miss in the respective level 1 cache. Accordingly, memory transactions that produce level 1 cache hits generally do not require access to pipeline banks 206 shown in FIG. 2, which control or intermediate memory access to L2 cache 116, L3 cache 119, and exterior functions 120 (see FIG. 1).

Pipeline banks 206 shown in FIG. 2 are part of UMC 114. L1D cache 110 can hold data generated by processor core 102. L2 cache 116 or L3 cache 119 can make data generated by processor core 102 available to exterior functions 120 by, for example, data being written to L2 cache 116 or L3 cache 119, or via snoop transactions from L2 cache controller 114 or L3 cache controller 118.

Memory coherence is when memory contents at logically the same address (or at least contents deemed or indicated as valid) throughout the memory system are the same contents expected by the one or more processors in the system based on an ordered stream of read and write requests. Writes affecting a particular data, or at a particular logical memory address, are prevented from bypassing earlier-issued writes or reads affecting the same data or the same memory address. Also, certain types of transactions take priority, such as victim cache transactions (no victim cache is shown) and snoop transactions.

A victim cache is a fully associative cache associated with a particular cache memory and may be configured so that if there is a cache hit, no action is taken with respect to the corresponding victim cache; if there is a cache miss and a victim cache hit, the corresponding memory lines are swapped between the cache and the victim cache; and if there is a cache miss and victim cache miss, data corresponding to the location in main memory producing the cache miss is written in a corresponding cache line, and the previous contents of the cache line are written in the victim cache. Fully associative means that data corresponding to any location in main memory can be written into any line of the victim cache.

Bus snooping is a scheme by which a coherence controller (snooper) in a cache monitors or snoops bus transactions to maintain memory coherence in distributed shared memory systems (such as in SoC 10). If a transaction modifying a shared cache block appears on a bus, the snoopers check whether their respective caches have a copy of data corresponding to the same logical address of the shared block. If a cache has a copy of the shared block, the corresponding snooper performs an action to ensure memory coherence in the cache. This action can be, for example, flushing, invalidating, or updating the shared block, according to the transaction detected on the bus.

At the first level of arbitration performed by initial scheduling block 202, UMC 114 (the L2 cache 116 controller, which includes initial scheduling block 202) determines whether to allow a memory transaction to proceed in memory pipeline 200, and in which pipeline bank 206 to proceed. Generally, each pipeline bank 206 is independent, such that read and write transactions on each pipeline bank 206 (for example, writes of data from L1D cache 110 to L2 cache 116) does not have ordering or coherency requirements with respect to write transactions on other pipeline banks 206. Within each pipeline bank, writes to L2 cache 116 proceed in the order they are scheduled. If a memory transaction causes an addressing hazard or violates an ordering requirement, the transaction stalls and is not issued to a pipeline bank 206.

A partial write request (also referred to herein as a partial write) is a write request with a data payload that includes a chunk (or more than one chunk) in which one or more, but less than all, bytes in the chunk will be written to the destination memory address. For example, in some systems, a write request data payload can be shorter than a destination memory's addressable location write length, but still equal to or larger than the location's minimum write length. Minimum write length refers to the amount of data that can be read from or written to a memory in a single clock cycle, which is generally determined by the physical width of the memory. Generally, a memory's minimum write length will be a multiple of the chunk length. For example, a memory with a 128 byte line length may have a 64 byte minimum write length, corresponding to writing to a first physical bank of a line of the memory (bytes 0 to 63 of the line) or a second physical bank of the memory line (bytes 64 to 127 of the line). An example partial write request can be to write a data payload from bytes 0 to 110 of the line, meaning that in one of the chunks of the data payload (the chunk corresponding to bytes 96 to 127 of the line), only 15 out of 32 bytes will be written (corresponding to bytes 96 to 110 of the line). Also, in some systems, a write request data payload can be sparse (sparse is a special case of partial write). A sparse data payload is configured to write a non-continuous set of bytes within a destination memory. For example, a data payload may be targeted to write to bytes 0 through 24 and 42 through 63 (or only the even-numbered bytes, or bytes 1, 15, and 27, or some other arbitrary arrangement) of a destination memory addressable location. If a write request data payload is configured to fill complete chunks in a complete destination memory addressable location, such as bytes 0 to 63 in the example above (or the full line corresponding to bytes 0 to 127), the write request will generally not be considered a partial write.

Partial writes trigger read-modify-write (RMW) operations. In an RMW operation, data is read from the destination cache memory in a read portion of the operation and used to supply those values not specified by the RMW operation and that are not to be changed by the operation. In this way, the data from the read portion conforms the data payload of the write portion of the operation to be continuous and full (not a partial write) to the destination cache memory's minimum write length. After this, an updated error correction code (ECC) is generated from and appended to the resulting conformed data payload to preserve data integrity of the unwritten data. The data payload in written to the destination cache memory with the updated ECC, with or without the conforming data. For example, in the example above in which the data payload includes bytes 0 through 24 and 42 through 63 (chunks corresponding to bytes 0 through 31 and 32 through 63 correspond to partial write), bytes 25 through 41 are read to conform the data payload to the 64 byte minimum write length.

FIG. 3 is a block diagram of an example RMW memory sub-pipeline 300, as part of processor 100, for processing RMW memory transactions. RMW memory sub-pipeline 300 conditionally processes a memory read request as part of a cache memory pipeline, such as part of a selected stage (for example, a stage selected from Stage 1 through Stage P) of memory pipeline 200 for UMC 114 (L2 cache controller), if a write request being processed by the selected stage involves an RMW operation. Accordingly, RMW memory sub-pipeline 300 processes a write request if a stage of a corresponding cache memory pipeline determines that an RMW operation is required by the write request. This is generally equivalent to determining whether the write request is a partial write.

Previous stage 316 is an ordinary-processing stage in a cache memory pipeline such as memory pipeline 200. “Ordinary-processing” refers to a pipeline stage that has functions that are performed in processing a memory transaction regardless of whether the memory transaction is a write request that is a partial write and that will be processed using an RMW operation. Previous stage 316 is connected to read from and write to a holding buffer 306. Holding buffer 306 can be, for example, a dedicated set of registers that is part of the memory controller that includes the RMW memory sub-pipeline 300, such as UMC 114.

Pipeline stage 302 is part of the RMW memory sub-pipeline 300, and is also an ordinary-processing stage in the cache memory pipeline. Pipeline stage 302 anchors (connects) RMW memory sub-pipeline 300 to the cache memory pipeline; accordingly, RMW memory sub-pipeline 300 branches off from the cache memory pipeline at pipeline stage 302, and in some systems, returns to (terminates at) the cache memory pipeline at pipeline stage 302. The connection between previous stage 316 and pipeline stage 302 is a dotted arrow to indicate that there may be additional pipeline stages executed between previous stage 316 and pipeline stage 302. Pipeline stage 302 receives a memory read request in a cache memory pipeline (including functions performed regardless of whether an RMW operation is required), such as pipeline stage 208 four (Stage 4 in a pipeline bank 206 in FIG. 2, not shown) in memory pipeline 200. (Pipeline stage 208 four can be, for example, hit and miss control.) Pipeline stage 302 is connected to read from, and write to, cache memory 304 (the cache memory to which the write request's data payload is to be committed). Pipeline stage 302 is also connected to write to the holding buffer 306. The data payload of a write request being processed by RMW memory sub-pipeline 300 is held in the holding buffer 306 during RMW processing.

Pipeline stage 302 is followed by an error detection stage 308. Error detection stage 308 is followed by an error correction stage 310. Error correction stage 310 is followed by a merge stage 312, which is connected to read from holding buffer 306. Merge stage 312 is followed by a syndrome generation stage 314. Syndrome generation stage 314 is followed by a return to pipeline stage 302.

Referring to FIG. 2, a separate RMW memory sub-pipeline 300 can be connected to a pipeline stage 302 in each separate pipeline bank 206 of a memory pipeline 200.

Returning to FIG. 3, when pipeline stage 302 receives a memory write request to process, pipeline stage 302 determines whether an RMW operation is required to make ECCs in a data payload of the write request properly correspond to (and accordingly, properly enable error correction of) respective chunks in the data payload. This determination can be made by, for example, determining whether the memory write request is a partial write, or by checking a flag set by a previous stage 208 in the corresponding pipeline bank 206 that determined whether the memory write request is a partial write. If an RMW operation is required, pipeline stage 302 issues a read request to the address in cache memory 304, and writes (commits) the write request's data payload to a holding buffer 306. If the read request from the pipeline stage 302 results in a cache miss, the data requested by the read request is retrieved from a lower level memory than the cache memory 304 to enable the read request to proceed. For example, if cache memory 304 is an L2 cache 116, then the requested data is retrieved from L3 cache 119 or other lower level memory.

The read request issued by pipeline stage 302 requests retrieval of each chunk in cache memory 304 corresponding to a same memory address as any portion of the write request's data payload. (The resulting data read from cache memory 304 is referred to herein, for convenience, as conforming data.) The conforming data's ECC syndrome is read along with the conforming data. In an example, a write request's data payload is configured to write bytes 0 to 38 in a line of cache memory 304, and chunks are 32 bytes long. Bytes 0 to 38 correspond to a first 32 byte chunk at bytes 0 to 31, and a second 32 byte chunk at bytes 32 to 63. An RMW operation will be indicated, and pipeline stage 302 will issue a read to cache memory 304 for bytes 0 to 63 of the corresponding line of memory, and the two corresponding ECC syndromes. Pipeline stage 302 also writes to holding buffer 306 the write request's data payload, including data, destination memory address, byte enables (indicating which bytes following a destination memory address the data corresponds to, such as, in the example above, bytes 0 to 38), and other control information.

After pipeline stage 302, error detection stage 308 determines whether there are any errors in the conforming data in light of the conforming data's ECC syndrome(s), and determines the type(s) and number(s) of bits of the errors in the conforming data (if any). After the error detection stage 308, the error correction stage 310 corrects the conforming data if necessary (as detected by the error detection stage 308) and possible. For example, in some systems, the conforming data can be corrected using a 10 bit ECC syndrome per 32 byte chunk if the conforming data contains a single one-bit error (or less) in each chunk. If the data cannot be corrected, an appropriate action is taken—for example, the write request may be dropped (discarded), and an exception may be taken.

After data correction stage 310, in merge stage 312, the conforming data is merged with the corresponding data (with exceptions described below, the data payload from the corresponding write request) in holding buffer 306. Accordingly, data from holding buffer 306 replaces (overwrites) corresponding bytes in the conforming data to form a new, merged data. In the example above in which the data payload corresponds to bytes 0 to 38 of a cache memory line, and the conforming data corresponds to bytes 0 to 63 of the cache memory line, the data payload replaces bytes 0 to 38 of the conforming data to form the merged data, also thereby leaving bytes 39 through 63 unchanged.

After merge stage 312, syndrome generation stage 314 uses the merged data to generate one or more new ECC syndromes (as required) corresponding to the merged data. In the example above, the data payload corresponds to bytes 0 to 38 of a cache memory line, and chunks are 32 bytes in length. Bytes 0 to 31 of the merged data do not require an ECC syndrome to be generated using an RMW operation because the corresponding data payload portion was a full chunk prior to merging (an ECC syndrome corresponding to the full chunk—bytes 0 to 31—could have been previously generated). A new ECC syndrome is calculated for bytes 32 to 63 of the merged data because the corresponding data payload portion overwrote only a portion of those bytes, that is, the written data was not a full chunk prior to merging (bytes 32 to 38). The resulting ECC syndrome, which is up-to-date with respect to the write request's data payload, is referred to as being in synchronization with the merged data. In some systems, ECC syndromes for chunks that the processor core 102 produces as full and continuous chunks can be generated at any time prior to the data payload being written to memory, such as prior to the write request being transmitted from DMC 104 (L1 cache controller) to UMC 114 (L2 cache controller).

After syndrome generation stage 314, the write request is returned to pipeline stage 302, and the write request's data payload, along with the new ECC syndrome, is written to cache memory 304. If the read request performed by the pipeline stage 302 resulted in a cache hit, then the data that is written can be only the write request's data payload (and the ECC syndromes corresponding to the chunks included in the data payload), or it can include the merged portion of the conforming data. The conforming data is required to generate a new ECC corresponding to the data payload, but can be optional when writing to the cache memory. The conforming data, having been read from the cache memory, should already be present in the cache memory if the read request performed by the pipeline stage 302 resulted in a cache hit. However, if the read request performed by the pipeline stage 302 resulted in a cache miss, then the data that is written includes the merged portion of the conforming data. An entry in holding buffer 306 corresponding to an RMW operation expires when the RMW operation completes (ends) after the data payload of the write request is written into the corresponding target cache memory. In some systems in which a cache write is completed a clock cycle after the syndrome generation stage is completed, holding buffer entry expiration can occur after generation of the new ECC syndrome by the syndrome generation stage 314.

In some systems, holding buffer 306 can have additional functionality to facilitate pipeline throughput and avoid stalls. The depth of holding buffer 306 is dependent on the total RMW memory pipeline 300 depth. For this purpose, pipeline stage 302 reading from the cache memory 304 is considered the beginning of RMW memory pipeline 300, and syndrome generation stage 314 completing generation of the new ECC syndrome is considered the end of the RMW memory pipeline 300. Holding buffer 306 contains information on all RMW operations that have begun and have not ended (or been terminated by an error, such as at error correction stage 310).

Previous stage 316 checks whether a write request requires an RMW operation. If so, previous stage 316 also checks in holding buffer 306 to find any pending RMW operation to the same address in cache memory 304 as the write request (a same-targeted write request). If there is such a pending RMW operation, then the current holding buffer 306 contents targeting that address, with corresponding byte enables, are combined with the most recent data targeting that address (generally, the contents of the data payload of the write request at previous stage 316). Accordingly, non-overlapping bytes of both the newer data and the older data are retained; if there is any overlap, the most recent data supersedes the specific overlapped bytes of the current holding buffer 306 contents; and the resulting combined data is written into an entry in the holding buffer 306 corresponding to the newer write request. (In some systems, this can be performed by writing the older data into the entry in the holding buffer 306 corresponding to the newer write request, and then performing an RMW operation on the newer write request so that the desired overwriting and resulting combined data is a consequence of the order of operations.) The pending RMW operation on the older data payload continues unaffected (corresponding holding buffer 306 contents are left unchanged), while the newer write request enters the RMW memory pipeline 300 for RMW processing of the combined data. (This is distinct from the case of a full line write—a write request that will write to a full line of the cache memory, and is accordingly not a partial write and does not require an RMW operation—as described below.) If the older write request has not yet finished processing and had its data payload written into the cache memory 304, then the address in the cache memory 304 targeted by the newer write request and the older write request contains data that is stale with respect to the newer write request. Stale data is data scheduled to be updated by a write request preceding the newer write request in a memory pipeline, such as the memory pipeline 200. Accordingly, the data-combining process described with respect to previous stage 316 prevents merge stage 312 from merging the newer write request with stale data. This additional holding buffer 306 functionality can be used, for example, in systems in which a write request can immediately follow another write request within a pipeline bank 206 (referring to FIG. 2), such as systems in which write requests can be issued in each cycle (for example, in systems with intended “write streaming” behavior).

Subject to an intervening read as described below, if previous stage 316 determines that the data payload of a write request corresponds to a full line write, and there is a pending RMW operation targeting the same address, the pending RMW operation is invalidated and the write request at the previous stage 316 proceeds (accordingly, is not stalled). (In some embodiments, this determination could be performed at pipeline stage 302, or a pipeline stage between previous stage 316 and pipeline stage 302.) Also, if a read request is received at a stage of an ordinary-processing cache memory pipeline (such as memory pipeline 200) at an intervening time between previous stage 316 and pipeline stage 302 that originated outside the RMW memory pipeline 300, then pending RMW operations are allowed to complete without allowing write requests at previous stage 316 to overwrite holding buffer 306 contents corresponding to the pending RMW operations.

FIG. 4A shows a table 400 providing an example list of different combinations of chunk contents in a data payload of a write request that targets a write at an address in a cache memory. The body 402 of table 400 is described by a title 404 “bytes in data payload to be written in memory line at target address.” Body 402 is divided into four titled columns, corresponding to chunks—in this example, 32 byte ranges 406—of data in a 128 byte maximum data payload of a write request. The four columns have the following titles: [31:0] (byte 0 to byte 31), [63:32] (byte 32 to byte 63), [95:64] (byte 64 to byte 95), and [127:96] (byte 96 to byte 127). The rows of body 402 are indexed in a column 412 with a title 414 “case.” Individual cells 416 in body 402 can correspond to a byte range for one of two scenarios, either in a data payload that contains data that will write all bytes (not a partial write) in a corresponding chunk at the target address—accordingly, labeled “all bytes”; or a data payload that contains data that will write less than all bytes in the corresponding chunk, resulting in a partial write—accordingly, labeled “partial.”

FIG. 4B shows a table 418 providing an example list of operations to use (e.g., RMW, full write, etc.) for corresponding cases of FIG. 4A. In a memory system corresponding to FIGS. 4A and 4B, a cache memory is comprised of cache memory lines. In the example, each cache memory line is 128 bytes in length. Each cache memory line has two physical banks (physical bank 0 and physical bank 1), each of length 64 bytes, and each physical bank has two virtual banks (virtual bank 0 and virtual bank 1), each of length 32 bytes. (Byte lengths of the cache line, physical banks, and virtual banks do not include additional related memory—not shown—storing corresponding ECC syndromes and other control information.) Each virtual bank 420, such as virtual bank 0 in physical bank 1, heads a column of a body 422 of table 418 of FIG. 4B. In this example cache memory, each physical bank (64 bytes each) can respectively be written in a single cycle 424 (cycle 1 or cycle 2) of a system clock (such as a clock 103 of a processor 100) by writing both of the physical bank's virtual banks 420 (32 bytes each). (Physical banks 0 and 1 cannot be written at the same time.) This means that 64 bytes in the 128 byte cache line can be written in a clock cycle, and the example cache memory has a 64 byte minimum write length. (In some systems, the example cache memory may also be able to write a full cache line in a single cycle.)

The cells 426 in body 422 are indexed by a column 428 titled 430 “case.” Entries in cells 426 are either “RMW,” meaning that a corresponding byte range for a corresponding case number (indexed in column 412 in FIG. 4A and column 428 in FIG. 4B) utilizes an RMW operation, or “write,” meaning that a corresponding byte range for a corresponding case number can be written to the cache memory without performing an RMW operation.

Physical bank 0, virtual bank 0 corresponds to (is written by) byte range 406 [31:0] of the write request data payload shown in table 400 of FIG. 4A. Physical bank 0, virtual bank 1 corresponds to (is written by) byte range 406 [63:32] of the write request data payload shown in table 400. Physical bank 1, virtual bank 0 corresponds to (is written by) byte range 406 [95:64] of the write request data payload shown in table 400. Physical bank 1, virtual bank 1 corresponds to (is written by) byte range 406 [127:96] of the write request data payload shown in table 400. The example 128 byte cache memory is four 32 byte chunks in length.

Accordingly, bytes in a data payload of a write request in a byte range [63:0] are written together, and bytes in the data payload of the write request in a byte range [127:64] are written together (writes are aligned at physical bank boundaries). This also means that the byte range [63:0] is written separately (and in a different clock cycle) from the byte range [127:64].

As shown in FIGS. 4A and 4B, for 64 byte writes aligned at physical bank boundaries (and that do not overlap with each other), when a chunk (a 32 byte range 406) in a particular case corresponds to a partial write, a write to the corresponding physical bank utilizes an RMW operation (performance of an RMW operation memory pipeline, such as RMW memory pipeline 300 of FIG. 3) on both chunks written to that physical bank. This is because an entire physical bank—64 bytes, corresponding to two chunks—is read or written together. For example, in cases 1, 2, 3, and 4 in table 400 of FIG. 4A, chunks corresponding to byte ranges 406 [127:96] and [95:64] correspond to partial writes (the corresponding entry is “partial”), meaning that an RMW operation is required. Accordingly, the entries for virtual banks 0 and 1 of physical bank 1 for cases 1, 2, 3, and 4 in table 418 of FIG. 4B are “RMW.” In another example, in cases 5, 6, 7, 8, 9, 10, 11, and 12, only one of the two chunks in byte ranges 406 [127:96] and [95:64] in table 400 corresponds to a partial write. (Byte range 406 [127:96] corresponds to a partial write in cases 5, 6, 7, and 8, and byte range 406 [95:64] corresponds to a partial write in cases 9, 10, 11, and 12.) However, because of the 64 byte minimum write length, as shown in table 418, both virtual banks 0 and 1 of physical bank 1 (respectively corresponding to byte ranges [95:64] and [127:96]) require an RMW operation. In another example, cases 13, 14, 15, and 16 show that “all bytes” in byte ranges 406 [127:96] and [95:64] will be written to the cache memory line by the data payload of the write request. Accordingly, table 418 shows that in cases 13, 14, 15, and 16, virtual banks 0 and 1 of physical bank 1 will be written to the cache memory line without performing an RMW operation (the corresponding table entries are “write”).

A minimum write length shorter than a cache memory line length can result in saving multiple clock cycles, and corresponding power expenditure, in completing processing of a write request in some cases. For example, in some systems (such as some systems using an RMW memory pipeline 300 of FIG. 3), completing an RMW operation through committing the corresponding data payload to memory from the RMW/no RMW decision point (for example, pipeline stage 302) may take six cycles, while completing a write operation (without RMW) through committing the corresponding data payload to memory from the RMW/no RMW decision point takes one cycle. Further, an RMW operation requires two memory transactions (a read and a write), while a write operation without RMW requires one memory transaction (a write). Also, there can be hazards that prevent full pipelining while an RMW operation is in progress. Savings realized by a minimum write length that is a shorter (such as an integer factor N shorter) than a memory cache line length are illustrated by cases 4, 8, 12, 13, 14, and 15 of FIG. 4B, in which RMW operation is not required for chunks written to one of the physical banks, despite an RMW operation being required for chunks written to the other physical bank.

FIG. 4C shows a table 432 providing an alternative example list of whether an RMW is utilized for corresponding cases of FIG. 4A. Similar content types in portions of table 432 of FIG. 4C to content types of corresponding portions of table 418 of FIG. 4B have the same identifying numbers. An example cache memory corresponding to FIG. 4C is similar to the example cache memory of FIGS. 4A and 4B, except that the example cache memory corresponding to FIG. 4C has a minimum cache memory write length of 32 bytes, the same length as the chunk length (and the virtual bank length). Writes according to table 432 do not overlap with each other (are non-overlapping) and are aligned with cache line boundaries. Accordingly, in table 432, only chunks corresponding to partial writes require RMW operations. For example and returning to table 400 of FIG. 4A, in case 6, a chunk to be written to physical bank 1, virtual bank 1 (byte range 406 [127:96]) is a partial write; a chunk to be written to physical bank 1, virtual bank 0 (byte range 406 [95:64]) is not a partial write (“all bytes”); a chunk to be written to physical bank 0, virtual bank 1 (byte range 406 [63:32]) is a partial write; and a chunk to be written to physical bank 0, virtual bank 0 (byte range 406 [31:0]) is not a partial write. For the case 6 example as applied to the 64 byte (double the chunk length) minimum write length of FIG. 4B, then in its table 418 (case 6), the case 6 example of partial write chunks and non-partial write chunks results in all chunks of the data payload requiring RMW operations. However, in the example of table 432 of FIG. 4C (case 6), with 32 byte minimum write length (equal to the chunk length), only the partial write chunks—the chunks to be written to physical bank 1, virtual bank 1 and physical bank 0, virtual bank 1—require RMW operations.

Consider a cache memory with cache memory lines of length L bytes, a minimum write length M bytes (aligned with memory bank boundaries) such that L/M≥1 is an integer (the number of writes to fully write a cache memory line), and a chunk length of P bytes such that there is an integer number L/P ≥1 chunks in a cache memory line. Generally, under these conditions, a chunk in a data payload corresponding to a partial write will require an RMW operation to be performed on an integer M/P≥1 chunks in the data payload. If L/M≥2, then a chunk in a data payload corresponding to a partial write may not require all chunks in the data payload written to the cache memory line to receive RMW operations. If M equals P, then chunks in the data payload that do not correspond to partial writes may not require RMW operations. (In some systems, only chunks in the data payload that correspond to partial writes will require RMW operations.)

Except where otherwise explicitly indicated (such as the number of bits in an ECC syndrome), memory lengths provided herein refer specifically to data, and not to control of data.

Modifications are possible in the described embodiments, and other embodiments are possible, within the scope of the claims.

In some embodiments, the streaming engine only receives and passes on read requests from the processor core, and returns read data to the processor core, rather than passing on and returning responses for both read and write requests.

In some embodiments, the processor can include multiple processor cores (embodiments with multiple processor cores are not shown), with similar and similarly-functioning couplings to DMC, the streaming engine, and PMC to those shown in and described with respect to FIG. 1. In some embodiments, processor includes different functional blocks.

In some embodiments, bus lines enabling parallel read or write requests can correspond to different types of read or write requests, such as directed at different blocks of memory or made for different purposes.

In some embodiments, the streaming engine enables the processor core to communicate directly with higher level cache (such as L2 cache), skipping lower level cache (such as L1 cache), to avoid data synchronization issues. This can be used to help maintain memory coherence. In some such embodiments, the streaming engine can be configured to transmit only read requests, rather than both read and write requests.

In some embodiments, different memory access pipeline banks can have different numbers of stages.

In some embodiments, syndrome generation stage 314 is followed by a return to a stage in the cache memory pipeline prior to pipeline stage 302, after arbitration and scheduling and cache hit detection.

In some embodiments, pipeline stage 302 can perform the functions of previous stage 316. In some embodiments, RMW memory sub-pipeline 300 can be anchored to the cache memory pipeline by a stage performing the functions of previous stage 316. In some embodiments, previous stage 316 can be considered part of RMW memory sub-pipeline 300. 

What is claimed is:
 1. A processor system comprising: a processor core configured to generate memory write requests; a cache memory; a memory controller having a holding buffer, and having a memory pipeline for processing the memory write requests to write data payloads of respective memory write requests to the cache memory, the memory pipeline including: an anchor stage configured to determine whether a first write request corresponds to a partial write, and if so, to write the data payload of the first write request to the holding buffer and read a set of conforming data from an address in the cache memory targeted by the first write request; and a read-modify-write (RMW) pipeline configured to operate on the first write request when the first write request corresponds to the partial write, the RMW pipeline including: a merge stage configured to read the data payload from the holding buffer, and to merge the set of conforming data with the data payload such that the data payload is retained to form merged data; and a syndrome generation stage configured to generate an error correction code (ECC) syndrome in response to the merged data; wherein the memory controller is configured to write the data payload and the ECC syndrome to the cache memory.
 2. The processor system of claim 1, wherein the anchor stage is configured to read, with the conforming data, a conforming data ECC syndrome corresponding to the conforming data; the RMW pipeline further including: an error detection stage configured to determine, in response to the conforming data ECC syndrome and the conforming data, whether there are error bits in the conforming data; an error correction stage configured to use the conforming data ECC syndrome to correct the error bits.
 3. The processor system of claim 1, wherein a depth of the holding buffer depends on a depth of the RMW pipeline.
 4. The processor system of claim 1, wherein the anchor stage is configured to, directly after the syndrome generation stage generates the ECC syndrome, write the data payload and the ECC syndrome to the cache memory.
 5. The processor system of claim 1, the memory pipeline further including a previous stage that is previous to the anchor stage in the memory pipeline, the previous stage configured to: first write determine whether the first write request corresponds to the partial write; same target determine whether same-targeted data corresponding to a previous write request targeting the address in the cache memory is stored in the holding buffer; and if the first write determine and same target determine actions both determine an affirmative, then write the same-targeted data to a portion of the holding buffer corresponding to the first write request, so that when the data payload is written to the holding buffer it will be written to the portion of the holding buffer and will overwrite any overlapping portions of the same-targeted data.
 6. The processor system of claim 5, wherein the partial write is a type of write request in which one or more, but less than all, bytes in a portion of a data payload of the type of write request that is error corrected by a particular ECC syndrome are configured to be written to a destination memory address of the write request.
 7. The processor system of claim 1, the memory pipeline further including a previous stage that is previous to the anchor stage in the memory pipeline, the previous stage configured to: full line write determine whether the data payload corresponds to a full line write of the cache memory; same target determine whether same-targeted data corresponding to a previous write request targeting a same address as the write request is stored in the holding buffer; and if the full line write determine and same target determine actions both determine an affirmative, then invalidate the previous write request.
 8. The processor system of claim 1, wherein the cache memory is a level 2 cache (L2 cache), and the memory controller is an L2 cache controller.
 9. The processor system of claim 1, wherein the memory pipeline includes multiple pipeline banks, each of the pipeline banks including an anchor stage and an RMW pipeline.
 10. The processor system of claim 1, wherein the data payload is comprised of multiple chunks and each of the chunks is error corrected by a corresponding ECC syndrome; wherein determining whether the data payload corresponds to a partial write comprises determining whether one or more of the chunks corresponds to the partial write; and wherein the memory pipeline is configured to perform RMW operations on as few chunks in the data payload corresponding to the partial write as possible while maintaining updated error correction.
 11. The processor system of claim 1, wherein the memory pipeline is configured to expire a content of the holding buffer that corresponds to a data payload that the syndrome generation stage has finished processing.
 12. A method of operating a processor system, the method comprising: receiving a write request in a memory pipeline, the write request corresponding to a partial write; and performing a read-modify-write (RMW) operation on the write request in the memory pipeline by: writing a data payload of the write request to a holding buffer; reading a set of conforming data from an address of the cache memory targeted by the write request; combining the data payload with the conforming data to generate a merged data; generating an error correction code (ECC) syndrome in response to the merged data; and writing the data payload and the ECC syndrome to the cache memory.
 13. The method of claim 12, further comprising: reading from the cache memory, with the conforming data, a conforming data ECC syndrome corresponding to the conforming data; determining, in response to the conforming data and the conforming data ECC syndrome, whether there are error bits in the conforming data; and correcting the error bits using the conforming data ECC syndrome.
 14. The method of claim 12, wherein, after the generating step, the write request is returned to a same memory pipeline stage that performed the writing to a holding buffer step and the reading a set of conforming data step; and wherein the same memory pipeline stage performs the writing to the cache memory step.
 15. The method of claim 12, further comprising: prior to the writing to a holding buffer step: determining whether the data payload requires an RMW operation; determining whether the write request targets a same address in the cache memory as a data stored in the holding buffer that corresponds to a previous write request; and if the determining steps both determine an affirmative, then writing the data stored in the holding buffer, as an updated data, to a portion of the holding buffer corresponding to the write request, so that when the data payload is written to the holding buffer, it will be written to the portion of the holding buffer and will overwrite any overlapping portions of the updated data.
 16. The method of claim 15, wherein the partial write is a type of write request in which one or more, but less than all, bytes in a portion of a data payload of the type of write request that is error corrected by an ECC syndrome are configured to be written to a destination memory address of the write request.
 17. The method of claim 12, further comprising: prior to the writing to a holding buffer step: determining whether the data payload corresponds to writing a full line of the cache memory; determining whether the write request targets a same address in the cache memory as a data stored in the holding buffer that corresponds to a previous write request; and if the determining steps both determine an affirmative, invalidating the previous write request.
 18. The method of claim 12, wherein the cache memory is a level 2 cache (L2 cache), and the memory pipeline is part of an L2 cache controller.
 19. The processor system of claim 12, wherein the memory pipeline includes multiple pipeline banks, and the method is performed independently by each of the pipeline banks.
 20. The method of claim 12, wherein the data payload is comprised of multiple chunks and each of the chunks is error corrected by a corresponding ECC syndrome; wherein the write request corresponds to the partial write if one or more of the chunks corresponds to the partial write; and wherein the writing, reading, combining, and generating steps are performed on as few of the chunks as possible while maintaining updated error correction.
 21. The method of claim 12, further comprising expiring contents of the holding buffer corresponding to the data payload after the generating step.
 22. The method of claim 12, further comprising: receiving another write request in a memory pipeline, the another write request not corresponding to the partial write; and not performing on the another write request the writing the data payload to the holding buffer step, the reading step, the combining step, the generating step, and the writing the data payload and the ECC syndrome to the cache memory step. 